using System;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("RemoteActionHandler")]
	public class RemoteActionHandler : MonoBehaviour
	{
		[Attribute38("RemoteActionHandler.CardAndID")]
		public class CardAndID : MonoClass
		{
			public int m_ID => method_2<int>("m_ID");

			public Entity m_entity => method_3<Entity>("m_entity");

			public Card m_card => method_3<Card>("m_card");

			public Card card => method_14<Card>("get_card", Array.Empty<object>());

			public int ID => method_11<int>("get_ID", Array.Empty<object>());

			public Entity entity => method_14<Entity>("get_entity", Array.Empty<object>());

			public CardAndID(IntPtr address, string className)
				: base(address, className)
			{
			}

			public CardAndID(IntPtr address)
				: this(address, "CardAndID")
			{
			}

			public void Clear()
			{
				method_8("Clear");
			}
		}

		[Attribute38("RemoteActionHandler.UserUI")]
		public class UserUI : MonoClass
		{
			public CardAndID over => method_3<CardAndID>("over");

			public CardAndID held => method_3<CardAndID>("held");

			public CardAndID origin => method_3<CardAndID>("origin");

			public UserUI(IntPtr address, string className)
				: base(address, className)
			{
			}

			public UserUI(IntPtr address)
				: this(address, "UserUI")
			{
			}

			public bool SameAs(UserUI compare)
			{
				return method_11<bool>("SameAs", new object[1] { compare });
			}

			public void CopyFrom(UserUI source)
			{
				method_8("CopyFrom", source);
			}
		}

		public static string TWEEN_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "RemoteActionHandler", "TWEEN_NAME");

		public static float DRIFT_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RemoteActionHandler", "DRIFT_TIME");

		public static float LOW_FREQ_SEND_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RemoteActionHandler", "LOW_FREQ_SEND_TIME");

		public static float HIGH_FREQ_SEND_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "RemoteActionHandler", "HIGH_FREQ_SEND_TIME");

		public UserUI myCurrentUI => method_3<UserUI>("myCurrentUI");

		public UserUI myLastUI => method_3<UserUI>("myLastUI");

		public UserUI enemyWantedUI => method_3<UserUI>("enemyWantedUI");

		public UserUI enemyActualUI => method_3<UserUI>("enemyActualUI");

		public UserUI friendlyWantedUI => method_3<UserUI>("friendlyWantedUI");

		public UserUI friendlyActualUI => method_3<UserUI>("friendlyActualUI");

		public float m_lastSendTime => method_2<float>("m_lastSendTime");

		public RemoteActionHandler(IntPtr address, string className)
			: base(address, className)
		{
		}

		public RemoteActionHandler(IntPtr address)
			: this(address, "RemoteActionHandler")
		{
		}

		public static RemoteActionHandler Get()
		{
			return MonoClass.smethod_15<RemoteActionHandler>(TritonHs.MainAssemblyPath, "", "RemoteActionHandler", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Update()
		{
			method_8("Update");
		}

		public Card GetOpponentHeldCard()
		{
			return method_14<Card>("GetOpponentHeldCard", Array.Empty<object>());
		}

		public Card GetFriendlyHoverCard()
		{
			return method_14<Card>("GetFriendlyHoverCard", Array.Empty<object>());
		}

		public Card GetFriendlyHeldCard()
		{
			return method_14<Card>("GetFriendlyHeldCard", Array.Empty<object>());
		}

		public void NotifyOpponentOfMouseOverEntity(Card card)
		{
			method_8("NotifyOpponentOfMouseOverEntity", card);
		}

		public void NotifyOpponentOfMouseOut()
		{
			method_8("NotifyOpponentOfMouseOut");
		}

		public void NotifyOpponentOfTargetModeBegin(Card card)
		{
			method_8("NotifyOpponentOfTargetModeBegin", card);
		}

		public void NotifyOpponentOfTargetEnd()
		{
			method_8("NotifyOpponentOfTargetEnd");
		}

		public void NotifyOpponentOfCardPickedUp(Card card)
		{
			method_8("NotifyOpponentOfCardPickedUp", card);
		}

		public void NotifyOpponentOfCardDropped()
		{
			method_8("NotifyOpponentOfCardDropped");
		}

		public void HandleAction(Network.UserUI newData)
		{
			method_8("HandleAction", newData);
		}

		public bool CanSendUI()
		{
			return method_11<bool>("CanSendUI", Array.Empty<object>());
		}

		public bool IsSendingTargetingArrow()
		{
			return method_11<bool>("IsSendingTargetingArrow", Array.Empty<object>());
		}

		public int GetOpponentHandHoverSlot()
		{
			return method_11<int>("GetOpponentHandHoverSlot", Array.Empty<object>());
		}

		public void UpdateCardOver()
		{
			method_8("UpdateCardOver");
		}

		public void UpdateCardHeld()
		{
			method_8("UpdateCardHeld");
		}

		public void StartDrift(bool isFriendlySide)
		{
			method_8("StartDrift", isFriendlySide);
		}

		public void DriftLeftAndRight(bool isFriendlySide)
		{
			method_8("DriftLeftAndRight", isFriendlySide);
		}

		public void StandUpright(bool isFriendlySide)
		{
			method_8("StandUpright", isFriendlySide);
		}

		public void MaybeDestroyArrow()
		{
			method_8("MaybeDestroyArrow");
		}

		public void MaybeCreateArrow()
		{
			method_8("MaybeCreateArrow");
		}

		public void UpdateTargetArrow()
		{
			method_8("UpdateTargetArrow");
		}

		public void SetArrowTarget()
		{
			method_8("SetArrowTarget");
		}

		public bool IsCardInHand(Card card)
		{
			return method_11<bool>("IsCardInHand", new object[1] { card });
		}

		public bool CanAnimateHeldCard(Card card)
		{
			return method_11<bool>("CanAnimateHeldCard", new object[1] { card });
		}

		public void OnTurnChanged(int oldTurn, int newTurn, object userData)
		{
			method_8("OnTurnChanged", oldTurn, newTurn, userData);
		}

		public bool CanReceiveEnemyEmote(EmoteType emoteType)
		{
			return method_11<bool>("CanReceiveEnemyEmote", new object[1] { emoteType });
		}
	}
}
